import javax.xml.soap.Node;
import java.util.*;

public class practice {

    /**
     * 给定一个单词列表words和一个整数 k ，返回前k个出现次数最多的单词。
     *
     * 返回的答案应该按单词出现频率由高到低排序。如果不同的单词有相同出现频率，
     * 按字典顺序 排序。
     * 示例 1：
     * 输入: words = ["i", "love", "leetcode", "i", "love", "coding"], k = 2
     * 输出: ["i", "love"]
     * 解析: "i" 和 "love" 为出现次数最多的两个单词，均为2次。
     *     注意，按字母顺序 "i" 在 "love" 之前

     */
    public List<String> topKFrequent(String[] words, int k) {

        //1.遍历数组 , 统计每个单词出现的 频率
        Map<String,Integer> hashMap = new HashMap<>();
        for (String s : words) {
            if (hashMap.get(s) == null) {
                hashMap.put(s,1);
            }else {
                hashMap.put(s,hashMap.get(s)+1);
            }
        }
        //2.建立小根堆
        PriorityQueue<Map.Entry<String,Integer>> minHeap = new PriorityQueue<>(
                k, new Comparator<Map.Entry<String, Integer>>() {
            @Override
            public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
               if (o1.getKey().compareTo(o2.getKey()) == 0) {
                   return o2.getKey().compareTo(o1.getKey());
               }
                return o1.getValue().compareTo(o2.getValue());
            }
        }
        ) ;
        //3.遍历hashMap 把里面的数据 放到小根堆
        for (Map.Entry<String,Integer> entry : hashMap.entrySet()) {
            if (minHeap.size() < k) {
                minHeap.offer(entry);
            }else {
                //小根堆放满了 k 个 , 下一个 entry 和堆顶元素比较
                Map.Entry<String,Integer> top = minHeap.peek();
                //堆顶的频率小于当前 entry 的频率 , 就出队 , 否则就入队
                if (top.getValue().compareTo(entry.getValue()) < 0) {
                    minHeap.poll();
                    minHeap.add(entry);
                }else {
                    //频率相同的情况下
                    if (top.getValue().compareTo(entry.getValue()) == 0) {
                        if (top.getKey().compareTo(entry.getKey()) > 0) {
                            minHeap.poll();
                            minHeap.add(entry);
                        }
                    }
                }
            }
        }
        //4.此时小根堆当中已经有了结果
        //System.out.println(minHeap);
        List<String> ret = new ArrayList<>();
        for (int i = 0; i < k; i++) {
            String key = minHeap.poll().getKey();
            ret.add(key);

        }
        Collections.reverse(ret);
        //System.out.println("ret" + ret);
        return ret;

    }

    /**
     *
     * 输入在2行中分别给出应该输入的文字、以及实际被输入的文字。
     * 每段文字是不超过80个字符的串，由字母A-Z（包括大、小写）、数字0-9、
     * 以及下划线“_”（代表空格）组成。题目保证2个字符串均非空。
     * 输出描述:
     * 按照发现顺序，在一行中输出坏掉的键。其中英文字母只输出大写，每个坏键只输出一次。题目保证至少有1个坏键。
     * 示例1
     * 输入
     * 7_This_is_a_test 期望
     * _hs_s_a_es  实际
     * 输出
     * 7TI
     */
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        while (scan.hasNextLine()) {
            String str1 = scan.nextLine();
            String str2 = scan.nextLine();
            func(str1,str2);
        }
    }

    private static void func(String str1, String str2) {
        Set<Character> set = new HashSet<>();
        //遍历实际输出的
        /**for (int i = 0; i < str2.length(); i++) {
            char ch = str2.charAt(i);
            set.add(ch);
        }*/
        for (char ch: str2.toUpperCase().toCharArray()) {
            set.add(ch);
        }
        //遍历期望输出的
        /**for (int i = 0; i < str1.length(); i++) {
            char ch = str1.charAt(i);
            if (!set.contains(ch)) {
                System.out.print(ch);
            }
        }*/
        Set<Character> setBroken = new HashSet<>();//避免输出重复,所以定义一个新set 存放坏的键,自动去重
        for (char ch:str1.toUpperCase().toCharArray()) {
            if (!set.contains(ch) && !setBroken.contains(ch)) {
                setBroken.add(ch);//将坏的键放进去后自动去重
                System.out.print(ch);
            }
        }

    }


    /**
     * 给你一个字符串 jewels代表石头中宝石的类型，
     * 另有一个字符串 stones 代表你拥有的石头。stones中每个字符代表了一种你拥有的石头的类型，
     * 你想知道你拥有的石头中有多少是宝石。
     * 字母区分大小写，因此 "a" 和 "A" 是不同类型的石头。
     * 示例 1：
     * 输入：jewels = "aA", stones = "aAAbbbb"
     * 输出：3
     */
    public int numJewelsInStones(String jewels, String stones) {
        Set<Character> set = new HashSet<>();
        int count = 0;
        //1.遍历jewels
        for (int i = 0; i < jewels.length(); i++) {
            char ch = jewels.charAt(i);
            set.add(ch);
        }
        //2.遍历石头
        for (int i = 0; i < stones.length(); i++) {
            char ch = stones.charAt(i);
            if (set.contains(ch)) {
                count++;
            }
        }
        return count;
    }


    /**
     * 复制带随机指针的链表
     */
    class Node {
        int val;
        Node next;
        Node random;

        public Node(int val) {
            this.val = val;
            this.next = null;
            this.random = null;
        }
    }
    public Node copyRandomList(Node head) {
        Map<Node,Node> map = new HashMap<>();
        Node cur = head;
        while(cur != null) {
            Node node = new Node(cur.val);
            map.put(cur,node);
            cur = cur.next;
        }
        cur = head;
        while(cur != null) {
            map.get(cur).next = map.get(cur.next);
            map.get(cur).random = map.get(cur.random);
            cur = cur.next;
        }
        return map.get(head);
    }

    /**
     * 找到只出现一次的数字
     */
    public int singleNumber(int[] nums) {
        Set<Integer> set = (Set<Integer>) new TreeSet();
        for (int i = 0; i < nums.length; i++) {
            if (!set.contains(nums[i])) {
                set.add(nums[i]);
            }else {
                set.remove(nums[i]);
            }
        }
        for (int i = 0; i < nums.length; i++) {
            if (set.contains(nums[i])) {
                return nums[i];
            }
        }
        return -1;
    }

    /**
     * 统计 10  个数据中 , 每个数据 出现的次数
     * 1.遍历数组 , x-> map , 里面有就val+1 , 没有就val = 1
     * 2.输出
     */
    public static void main3(String[] args) {
        int[] array = {1,2,3,1,8,6,3,1,2,8};
        Map<Integer,Integer> map = new TreeMap<>();
        for (int x : array) {
            if (map.get(x) == null) {
                map.put(x,1);
            }else {
                int val = map.get(x);
                map.put(x,val+1);
            }
        }
        System.out.println(map);

    }
    /**
     * 有 10 个数据 , 并且有重复的 ,去重
     */
    public static void main1(String[] args) {
        int[] array = {1,2,3,1,5,6,3,1,2,8};
        Set<Integer> set = (Set<Integer>) new TreeSet();
        for (int x:array) {
            set.add(x);
        }
        System.out.print(set);
    }
    /**
     * 有 10 个数据 , 并且有重复的 , 找到第一个重复数据
     */
    public static void main2(String[] args) {
        int[] array = {1,2,3,1,5,6,3,1,2,8};
        Set<Integer> set = (Set<Integer>) new TreeSet();
        for (int x:array) {
            if (!set.contains(x)) {
                set.add(x);
            }else {
                System.out.println(x);
                return;
            }
        }
    }
}
